/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package edu.eam.gui;

import edu.eam.dao.DAOAdmon;
import edu.eam.dao.DAOCategoria;
import edu.eam.modelo.Categoria;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

/**
 *
 * @author Fabian
 */
public class CrearCategoriaSubCategoria extends javax.swing.JFrame {

    
    private DefaultTreeModel modelo;
    /**
     * Creates new form CrearCategoriaSubCategoria
     */
    public CrearCategoriaSubCategoria() {
        //Mostramos los componentes
        initComponents();
        //Lllamamos el metodo que permite mostrar las categorias en el arbol
        llenarArbol();        
        setVisible(true);
        this.setTitle("Categorias y subcategorias");
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jPanel1 = new javax.swing.JPanel();
        jScrollPane1 = new javax.swing.JScrollPane();
        JTArbol = new javax.swing.JTree();
        bCrear = new javax.swing.JButton();
        tfNombre = new javax.swing.JTextField();
        jLabel1 = new javax.swing.JLabel();
        bCancelar = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        jPanel1.setLayout(null);

        jScrollPane1.setViewportView(JTArbol);

        jPanel1.add(jScrollPane1);
        jScrollPane1.setBounds(10, 10, 240, 380);

        bCrear.setText("Crear");
        bCrear.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                bCrearActionPerformed(evt);
            }
        });
        jPanel1.add(bCrear);
        bCrear.setBounds(10, 440, 110, 23);
        jPanel1.add(tfNombre);
        tfNombre.setBounds(70, 400, 170, 30);

        jLabel1.setText("Nombre:");
        jPanel1.add(jLabel1);
        jLabel1.setBounds(10, 400, 60, 14);

        bCancelar.setText("Cancelar");
        bCancelar.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                bCancelarActionPerformed(evt);
            }
        });
        jPanel1.add(bCancelar);
        bCancelar.setBounds(130, 440, 110, 23);

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, 263, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, 475, Short.MAX_VALUE)
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void bCrearActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_bCrearActionPerformed
        //Obtenemos el nombre de la nueva categoria
        String nombreCategoria = tfNombre.getText();
        //Buscamos el nodo seleccionado
        TreePath path = JTArbol.getSelectionPath();
        if (path != null) {
            Object nodo = path.getLastPathComponent();        
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) nodo;
            //hacemos cash del DefaultMutableTreeNode a tipo Object
            Object noinfo = node.getUserObject();
            //Hacemos cash del Object a la case Categoria
            Categoria nodoDeArbol = (Categoria) noinfo;
            //El nombre de la categoria no puede ser menor a 4 caracteres ni 
            //mayor a 15.
            if (nombreCategoria.length() >= 4 && nombreCategoria.length() <= 15) {
                insertarSubcategoria(nombreCategoria, nodoDeArbol);
            } else {
                JOptionPane.showMessageDialog(null, "El nombre de la categoría "
                        + "no puede ser menor a 4 caracteres ni mayor a 15 caracteres", 
                        "Error", JOptionPane.ERROR_MESSAGE);
            }
            
        } else {
            JOptionPane.showMessageDialog(null, "Debe seleccionar un nodo padre "
                    + "en el arbol ");
        }
            
        
    }//GEN-LAST:event_bCrearActionPerformed

    private void bCancelarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_bCancelarActionPerformed
        // TODO add your handling code here:
        this.dispose();
    }//GEN-LAST:event_bCancelarActionPerformed

   
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JTree JTArbol;
    private javax.swing.JButton bCancelar;
    private javax.swing.JButton bCrear;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTextField tfNombre;
    // End of variables declaration//GEN-END:variables

    /**
     * Metodo que permite agregar nodos hijos a nodos padre.
     * Buscandole a cada hjio su respectivo padre y agregandole posteriormente
     * dicho nodo.
     * @param TreeNode nodoRaiz
     * @param categoriaInsertar 
     */
    public void imprimirNodo(TreeNode nodoRaiz, Categoria categoriaInsertar) {
        //Convertimos el nodo raiz a un objeto DefaultMutableTreeNode.
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) nodoRaiz;
        //hacemos cash del DefaultMutableTreeNode a tipo Object
        Object noinfo = node.getUserObject();
        //Hacemos cash del Object a la case Categoria
        Categoria nodoDeArbol = (Categoria) noinfo;
        //Si el padre de la categoria a insertar es igual al codigo del nodo arbol
        //que llega al metodo como nodo raiz.
        if (categoriaInsertar.getPadre() == nodoDeArbol.getCodigo()) {
            //Si encontramos el padre de la categoria creamos un DefaultMutableTreeNode
            //con la categoria a insertar.
            DefaultMutableTreeNode nodoInsertar = new DefaultMutableTreeNode(categoriaInsertar);
            //Ahora le agregamos al DefaultMutableTreeNode el nodo hijo.
            node.add(nodoInsertar);
        } else {
            //De no ser el padre el nodo raiz de la categoria que vamos a insertar
            //preguntamos si el nodo raiz tiene hijos, y llamar el metodo 
            //recursivamente hasta recorrer todos los nodos.
            if (nodoRaiz.getChildCount() >= 0) {
                //Obtenemos el nodo siguiente
                for (Enumeration e = nodoRaiz.children(); e.hasMoreElements();) {
                    //hacemos un cash a TreeNode del elemento siguiente
                    TreeNode nuevoNodoSiguiente = (TreeNode) e.nextElement();
                    //Lamamos el metodo recursivamente y enviamos un nuevo nodo.
                    imprimirNodo(nuevoNodoSiguiente, categoriaInsertar);
                }
            }
        }
    }

    /**
     * Metodo que nos permite mostrar en el JTree de las categorias cada uno 
     * de los nodos (categorias y subcategorias) que tenemos almacenados.
     */
    private void llenarArbol() {
        //Llamamos la clase padre.
        Categoria categoriaPadre = getCategoriasPadre();
        //Colocamos la clase padre como inicial o raiz del arbol
        DefaultMutableTreeNode top = new DefaultMutableTreeNode(categoriaPadre);
        //Agregamos la raiz al modelo.
        modelo = new DefaultTreeModel(top);
        //Obtenemos todas las categorias a mostrar.
        ArrayList<Categoria> categorias = getTodaCategorias();
        int padre = 0;
        //Recorremos cada categoria para mostrarla en el arbol.
        for (Categoria categoria : categorias) {
            //Si el arreglo se recorre por primera vez, no dejamos agregar el nodo
            //porque se estaria agregando el nodo raiz al nodo raiz
            if (padre == 0) {
                padre ++;
                continue;
            }
            imprimirNodo((TreeNode) modelo.getRoot(), categoria);
        }
        //Agregamos el modelo al arbol con todas las categorias
        JTArbol.setModel(modelo);
    }
    
    /**
     * Metodo que nos trae de la base de datos todas las categorias existentes
     * @return 
     */
    public ArrayList<Categoria> getTodaCategorias() {
        Connection con = null;
        ArrayList<Categoria> categorias = new ArrayList<Categoria>();
        try {
            con = DAOAdmon.crearConeccion();
            DAOCategoria daoCategoria = new DAOCategoria(con);
            //Obtenemos las categorias y las almacenamos en un arreglo.
            categorias = daoCategoria.todasLasCategoriasParaArbol();
        } catch (SQLException ex) {
            Logger.getLogger(CrearCategoriaSubCategoria.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(CrearCategoriaSubCategoria.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
        return categorias;
    }
    
    /**
     * Metodo que obtiene la categoria padre (razi) de la base de datos
     * @return 
     */
    public Categoria getCategoriasPadre() {
        Connection con = null;
        Categoria categoriaPadre = null;
        try {
            con = DAOAdmon.crearConeccion();
            DAOCategoria daoCategoria = new DAOCategoria(con);
            //Buscamos la categoria padre 0
            categoriaPadre = daoCategoria.buscarCategoriaPorID(0);
        } catch (SQLException ex) {
            Logger.getLogger(CrearCategoriaSubCategoria.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(CrearCategoriaSubCategoria.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
        return categoriaPadre;
    }

    /**
     * Metodo que nos permite agregar una nueva subcategoria a la base de datos.
     * @param nombreCategoria
     * @param nodoDeArbol 
     */
    private void insertarSubcategoria(String nombreCategoria, Categoria nodoDeArbol) {
        Connection con = null;
        try {
            con = DAOAdmon.crearConeccion();
            DAOCategoria daoCategoria = new DAOCategoria(con);          
            //Insertamos la nueva categoria
            daoCategoria.crearCategoria(new Categoria(0, nombreCategoria, nodoDeArbol.getCodigo()));
            //Mostramos nuevamente el arbol
            llenarArbol();
            //Limpiamos el campo de nombre.
            tfNombre.setText("");
        } catch (Exception ex) {
            JOptionPane.showMessageDialog(null, ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
        }  finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(CrearCategoriaSubCategoria.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    } 
    }
